FLASH.c

Go to the documentation of this file.

#include "Compile_Options.h"
#include "derivative.h"
#include "utils.h" /* For Copy Array */
#include "flash.h"
/*
 ******************************************************************************
 * constants
 ******************************************************************************
 */
 /*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
/*
 ******************************************************************************
 * u8fnFlashWriteDataFromRAM
 ******************************************************************************
 */
static uint8_t u8fnFlashWriteDataFromRAM(uint32_t* pu32AddressToWrite, \
                                         uint32_t* pu32ValueToWrite,   \
                                         Flash_t  ptFlashInstance,     \
                                         uint8_t  u8TwoContiguousWords)
{
  uint8_t  u8Status;
  uint16_t u16TimeOut;
  
  u8Status = CLEAR;
  u16TimeOut = CLEAR;
  
  /* The first instruction selects the desired operation by setting its  */
  /* corresponding selection bit in MCR                                  */
  ptFlashInstance->MCR.B.PGM = TRUE;
  
  /* Next, write to the location so that the flash controller takes the  */
  /* values.                                                             */
  *pu32AddressToWrite = *pu32ValueToWrite;
  if(TRUE == u8TwoContiguousWords)
  {
    *(++pu32AddressToWrite) = *(++pu32ValueToWrite);
  }
  else
  {
    /* Nothing */
  }
  
  /* Set MCR[EHV] to 1 to start the internal program sequence */
  ptFlashInstance->MCR.B.EHV = TRUE;
  
  /* Wait for the programming to be done */
  do
  {
    u16TimeOut++;
  }while((CLEAR == ptFlashInstance->MCR.B.DONE) && \
         (FLASHING_TIMEOUT > u16TimeOut));
  
  if(FLASHING_TIMEOUT == u16TimeOut)
  {
    /* We timed-out. We need to flag this */
    u8Status = STATUS_FLASHING_TIME_OUT;
  }
  else
  {
    /* Nothing happened */
  }
  /* Confirm MCR[PEG] = 1. */
  if(TRUE != ptFlashInstance->MCR.B.PEG)
  {
    /* Set a flag */
    u8Status = STATUS_PROGRAMMED_WRONG;
  }
  else
  {
    /* We are happy */
  }
      
  /* Write a logic 0 to the MCR[EHV] bit. */
  ptFlashInstance->MCR.B.EHV = CLEAR;
  /* Write a logic 0 to the MCR[PGM] bit to terminate the program operation */
  ptFlashInstance->MCR.B.PGM = CLEAR;  
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnFlashEraseFromRAM
 ******************************************************************************
 */
static uint8_t u8fnFlashEraseFromRAM(Flash_t ptFlashInstance, uint32_t u32LMS)
{
  uint8_t  u8Status;
  uint32_t u32TimeOut;
  
  u8Status = CLEAR;
  u32TimeOut = CLEAR;
  
  /* 1. Change the value in the MCR[ERS] bit from 0 to 1. */
  ptFlashInstance->MCR.B.ERS = TRUE;
    
  /* According to the spec, start by selecting sectors that will be erased */
  ptFlashInstance->LMS.R = u32LMS;
    
  /* Write to any address in flash. This is referred to as an erase */
  /* interlock write.                                               */
  *(uint32_t*)DATA_FLASH_F3_SECTOR_MIN = CLEAR;
  *(uint32_t*)CODE_FLASH_F3_SECTOR_MIN = CLEAR;
  
  /* Set MCR[EHV] to start the internal erase sequence */
  ptFlashInstance->MCR.B.EHV = TRUE;
  
  u32TimeOut = CLEAR;
  /* Wait for the operation to be done */
  do
  {
    u32TimeOut++;
  }while((CLEAR == ptFlashInstance->MCR.B.DONE) && \
         (ERASING_TIMEOUT > u32TimeOut));
  
  if(ERASING_TIMEOUT == u32TimeOut)
  {
    /* We timed-out. We need to flag this */
    u8Status = STATUS_FLASHING_TIME_OUT;
  }
  else
  {
    /* Nothing happened */
  }
  
  /* Confirm MCR[PEG] = 1. */
  if(TRUE != ptFlashInstance->MCR.B.PEG)
  {
    /* Set a flag */
    u8Status = STATUS_PROGRAMMED_WRONG;
  }
  else
  {
    /* We are happy */
  }
   /* Write a logic 0 to the MCR[EHV] bit. */
  ptFlashInstance->MCR.B.EHV = CLEAR;

  /* Write a logic 0 to the MCR[ERS] bit to terminate the program operation */
  ptFlashInstance->MCR.B.ERS = CLEAR;  
  
  return(u8Status);
}
/*
 ******************************************************************************
 * vfnFlashArray
 ******************************************************************************
 */
uint8_t u8fnFlashWrite(uint32_t* pu32Source, uint32_t* pu32Destination, \
                       uint16_t u16Size)
{
  Flash_t ptFlashInstance;
  uint8_t u8Status;
  uint8_t u8Sector;
  uint8_t u8TwoBytesAtOnce;
  
  /* Init local variables and select flash instance */
  u8Status = CLEAR;
  u8Sector = CLEAR;
  u8TwoBytesAtOnce = CLEAR;
  ptFlashInstance = tfnFlashSelectInstance(\
                               u8fnReturnTypeOfFlash(\
                                      (uint32_t)(pu32Destination + u16Size)));
  /* If we still have a valid instance */
  if(CLEAR != ptFlashInstance)
  {
    /* Clear the lock - this is a write-once per reset operation.         */
    /* In the spec, p. 379, 382, passwords are defined for editing LML    */
    /* and SLL. These are written here first.                             */
    ptFlashInstance->LML.R = FLASH_PRIMARY_LOCK_KEY;
    ptFlashInstance->LML.R = FLASH_ALLOW_COMPLETE_REFLASH;
    ptFlashInstance->SLL.R = FLASH_SECONDARY_LOCK_KEY;
    ptFlashInstance->SLL.R = FLASH_ALLOW_COMPLETE_REFLASH;
    
    /* Copy the flashing routine to RAM from where we will execute */
    vfnCopyArray((uint8_t*)&u8fnFlashWriteDataFromRAM, \
                 (uint8_t*)RAM_ADDRESS_FOR_FLASHING_ROUTINE,
                 FLASH_ROUTINE_SIZE);
  
    for(; u16Size > CLEAR; u16Size--)
    {
      if(NOT_FLASHABLE != u8Sector)
      {
        /* If we can flash, let's see if we're writing one or two words at */
        /* the same time. This is a hardware capability.                   */
        if(1u < u16Size)
        {
          /* If BIT3 is clear we know that the destination address will is */
          /* at the start of a 64-bit register, and therefore we can flash */
          /* two 32-bit words at once.                                     */
          if((uint32_t)pu32Destination & BIT3)
          {
            u8TwoBytesAtOnce = CLEAR;
          }
          else
          {
            u8TwoBytesAtOnce = TRUE;
          }
        }
        else
        {
          u8TwoBytesAtOnce = CLEAR;
        }
      
        /* Now, let's actually program by jumping into RAM. */
        u8Status |= PROGRAM(pu32Destination, pu32Source, ptFlashInstance, u8TwoBytesAtOnce);
      } /* end if */
      else
      {
        u8Status = u8Sector;
      }
    
      /* Let's Increment our pointers coherently with how many values were */
      /* flashed                                                           */
      pu32Destination += (1 + u8TwoBytesAtOnce);
      pu32Source += (1 + u8TwoBytesAtOnce);
    
      /* Also, don't forget to decrement size manually if two words were   */
      /* flashed.                                                          */
      u16Size -= u8TwoBytesAtOnce;
    
    }/* End For */
  } /* end if memory locations are valid */
  else
  {
    u8Status = NOT_FLASHABLE;
  }
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnFlashErase
 ******************************************************************************
 */
uint8_t u8fnFlashErase(uint32_t* pu32DataToErase)
{
  uint8_t  u8Status;
  uint8_t  u8TypeOfFlash;
  uint8_t  u8FlashSector;
  uint32_t u32LMS;
  Flash_t  ptMyFlash;
  
  /* Init locals */
  u8Status = CLEAR;
  u8FlashSector = CLEAR;
  u32LMS = CLEAR;
  
  /* Figure out what module we will be erasing */
  u8TypeOfFlash = u8fnReturnTypeOfFlash((uint32_t)pu32DataToErase);
  
  if(DATA_FLASH == u8TypeOfFlash)
  {
    /* Define instance as Data flash. */
    ptMyFlash = (Flash_t)&DFLASH;
    u8FlashSector = u8fnReturnDataFlashSector((uint32_t)pu32DataToErase);
  }
  else if(CODE_FLASH == u8TypeOfFlash)
  {
    /* Define instance as Code  flash. */
    ptMyFlash = &CFLASH;
    u8FlashSector = u8fnReturnCodeFlashSector((uint32_t)pu32DataToErase);
  }
  else
  {
    u8Status = NOT_FLASHABLE;
  }
  
  if(CLEAR == u8Status)
  {
    if(NOT_FLASHABLE != u8FlashSector)
    {
      /* Clear the lock - this is a write-once per reset operation.         */
      /* In the spec, p. 379, 382, passwords are defined for editing LML    */
      /* and SLL. These are written here first.                             */
      ptMyFlash->LML.R = FLASH_PRIMARY_LOCK_KEY;
      ptMyFlash->LML.R = FLASH_ALLOW_COMPLETE_REFLASH;
      ptMyFlash->SLL.R = FLASH_SECONDARY_LOCK_KEY;
      ptMyFlash->SLL.R = FLASH_ALLOW_COMPLETE_REFLASH;
      
      /* Copy the erase routine to RAM from where we will execute */
      vfnCopyArray((uint8_t*)&u8fnFlashEraseFromRAM, \
                   (uint8_t*)RAM_ADDRESS_FOR_FLASHING_ROUTINE,
                   ERASE_ROUTINE_SIZE);
      /* Figure out what LMS bits will be set - this is directly mapped */
      /* to Hardware.                                                   */
      u32LMS = u32fnFlashSectorToLMS(u8FlashSector);
      
      /* Now ERASE!! */
      u8Status = ERASE(ptMyFlash, u32LMS);
          
    }
    else
    {
      u8Status = NOT_FLASHABLE;
    }
  }
  else
  {
    /* Already flagged - exit */
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnReturnTypeOfFlash
 ******************************************************************************
 */
static uint8_t u8fnReturnTypeOfFlash(uint32_t u32Location)
{
  uint8_t u8Status;
  
  u8Status = CLEAR;
  
  if((CODE_FLASH_ARRAY_0_TOP_ADDRESS >= u32Location) && \
     (CODE_FLASH_ARRAY_0_MIN_ADDRESS <= u32Location))
  {
    u8Status = CODE_FLASH;
  }
  else if((CODE_FLASH_ARRAY_0_SHADOW_TOP_ADDRESS >= u32Location) && \
          (CODE_FLASH_ARRAY_0_SHADOW_MIN_ADDRESS <= u32Location))
  {
    u8Status = CODE_FLASH_SHADOW;
  }
  else if((DATA_FLASH_ARRAY_0_TOP_ADDRESS >= u32Location) && \
          (DATA_FLASH_ARRAY_0_MIN_ADDRESS <= u32Location))
  {
    u8Status = DATA_FLASH;
  }
  else
  {
    u8Status = NOT_FLASHABLE;
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * tfnFlashSelectInstance
 ******************************************************************************
 */
static Flash_t tfnFlashSelectInstance(uint8_t u8Instance)
{
  Flash_t ptFlashInstance;
  if(CODE_FLASH == u8Instance)
  {
    ptFlashInstance = &CFLASH;
  }
  else if(DATA_FLASH == u8Instance)
  {
    ptFlashInstance = (Flash_t)&DFLASH;
  }
  else
  {
    ptFlashInstance = CLEAR;
  }
  
  return(ptFlashInstance);
}
/*
 ******************************************************************************
 * u8fnFlashReadBackInstance
 ******************************************************************************
 */
static uint8_t u8fnFlashReadBackInstance(Flash_t ptFlashInstance)
{
  uint8_t u8FlashInstance;
  if(ptFlashInstance == &CFLASH)
  {
    u8FlashInstance = CODE_FLASH;
  }
  else if(ptFlashInstance == (Flash_t)&DFLASH)
  {
    u8FlashInstance = DATA_FLASH;
  }
  else
  {
    u8FlashInstance = NOT_FLASHABLE;
  }
  
  return(u8FlashInstance);
}
/*
 ******************************************************************************
 * u8fnReturnCodeFlashSector
 ******************************************************************************
 */
static uint8_t u8fnReturnCodeFlashSector(uint32_t u32Address)
{
  uint8_t u8Status;
    
  u8Status = CLEAR;
  
  /* This should only be true if the passed address is in the valid region */
  if(CODE_FLASH_ARRAY_0_TOP_ADDRESS >= u32Address)
  {
    if(CODE_FLASH_F1_SECTOR_MIN > u32Address)
    {
      u8Status = F0;
    }
    else if(CODE_FLASH_F2_SECTOR_MIN > u32Address)
    {
      u8Status = F1;
    }
    else if(CODE_FLASH_F3_SECTOR_MIN > u32Address)
    {
      u8Status = F2;
    }
    else if(CODE_FLASH_F4_SECTOR_MIN > u32Address)
    {
      u8Status = F3;
    }
    else if(CODE_FLASH_F5_SECTOR_MIN > u32Address)
    {
      u8Status = F4;
    }
    else if(CODE_FLASH_F6_SECTOR_MIN > u32Address)
    {
      u8Status = F5;
    }
    else if(CODE_FLASH_F7_SECTOR_MIN > u32Address)
    {
      u8Status = F6;
    }
    else if(CODE_FLASH_F7_SECTOR_MAX >= u32Address)
    {
      u8Status = F7;
    }
    else
    {
      u8Status = NOT_FLASHABLE;
    }
  }
  else
  {
    u8Status = NOT_FLASHABLE;
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnReturnTypeOfFlash
 ******************************************************************************
 */
static uint8_t u8fnReturnDataFlashSector(uint32_t u32Address)
{
  uint8_t u8Status;
    
  u8Status = CLEAR;
  
  /* This should only be true if the passed address is in the valid region */
  if(DATA_FLASH_F0_SECTOR_MIN <= u32Address)
  {
    u32Address -= DATA_FLASH_F0_SECTOR_MIN;
    u8Status = (uint8_t)(u32Address / DATA_FLASH_SECTOR_SIZE);
  }
  else
  {
    u8Status = NOT_FLASHABLE;
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnFlashSectorToLMS
 ******************************************************************************
 */
static uint32_t u32fnFlashSectorToLMS(uint8_t u8Sector)
{
  uint32_t u32LMS;
  
  u32LMS = CLEAR;
  
  /* Start with Mid address spaces */
  if(F6 <= u8Sector)
  {
    /* Set the corresponding bits for MSL within LMS - Bits 14 + 15 according */
    /* to spec.                                                               */
    u32LMS = (1u << ((u8Sector - F6) + BITS_IN_16)); 
  }
  else
  {
    u32LMS = (1u << u8Sector);
  }
  
  return(u32LMS);
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */